package com.shf.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;

import com.shf.constants.SystemCanstants;
import com.shf.domain.entity.Menu;
import com.shf.mapper.MenuMapper;
import com.shf.service.MenuService;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/**
 * @author 35238
 * @date 2023/11/20.
 */
@Service
public class MenuServiceImpl extends ServiceImpl<MenuMapper, Menu> implements MenuService {
    @Override
    //查询用户的权限信息
    public List<String> selectPermsByUserId(Long id) {
        //根据用户id查询用户的权限信息。用户id为id代表管理员，如果是管理员就返回所有的权限
        if(id == 1L){
            LambdaQueryWrapper<Menu> wrapper = new LambdaQueryWrapper<>();
            //查询条件是permissions中需要有所有菜单类型为C或者F的权限。SystemCanstants是我们在huanf-framework工程写的类
            wrapper.in(Menu::getMenuType, SystemCanstants.TYPE_MENU,SystemCanstants.TYPE_BUTTON);
            //查询条件是permissions中需要有状态为正常的权限。SystemCanstants是我们在huanf-framework工程写的类
            wrapper.eq(Menu::getStatus,SystemCanstants.STATUS_NORMAL);
            //查询条件是permissions中需要未被删除的权限的权限
            List<Menu> menus = list(wrapper);
            List<String> perms = menus.stream()
                    .map(Menu::getPerms)
                    .collect(Collectors.toList());
            return perms;
        }

        //如果不是管理员就返回对应用户所具有的权限
        List<String> otherPerms = getBaseMapper().selectPermsByOtherUserId(id);
        return otherPerms;
    }


    @Override
    public List<Menu> selectRouterMenuTreeByUserId(Long userId) {
        MenuMapper menuMapper = getBaseMapper();
        List<Menu> menus = null;
        //判断是否是超级管理员，用户id为id代表超级管理员，如果是就返回所有符合要求的权限菜单
        if (userId.equals(1L)){
            //如果是超级管理员，返回所有菜单
             menus = menuMapper.selectAllRouterMenu();
        }else {
            //先查询对应的权限菜单
            menus = menuMapper.selectOtherRouterMenuTreeByUserId(userId);

        }
        //先查询所有的父级菜单
        //在查询父级对应的子集菜单
        List<Menu> menuTree = buildMenuTree(menus,0L);

        return menuTree;

    }

    /**
     * 查询菜单列表
     * @param menu
     * @return
     */
    @Override
    public List<Menu> selectMenuList(Menu menu) {
        //模糊查询
        LambdaQueryWrapper<Menu> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.like(StringUtils.hasText(menu.getMenuName()),Menu::getMenuName,menu.getMenuName())
                .eq(StringUtils.hasText(menu.getStatus()), Menu::getStatus,menu.getStatus());
        //根据parent——id和order_num排序
        queryWrapper.orderByAsc(Menu::getParentId,Menu::getOrderNum);
        List<Menu> menuList = list(queryWrapper);
        return menuList;
    }

    @Override
    public boolean hasChild(Long menuId) {
        LambdaQueryWrapper<Menu> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(Menu::getParentId,menuId);
        int count = count(queryWrapper);
        return count > 0;
    }

    @Override
    public List<Long> selectMenuListByRoleId(Long roleId) {
        return getBaseMapper().selectMenuListByRoleId(roleId);
    }
    /**
     * 构建菜单树
     *
     * @param menuList 菜单列表
     * @param parentId 父菜单ID
     * @return 菜单树
     */
    private List<Menu> buildMenuTree(List<Menu> menuList, long parentId) {
        // 使用Map存储菜单项
        Map<Long, List<Menu>> menuMap = new HashMap<>();
        for (Menu menu : menuList) {
            // 将菜单项按照父菜单ID分组，存储到Map中
            menuMap.computeIfAbsent(menu.getParentId(), k -> new ArrayList<>()).add(menu);
        }
        // 递归构建菜单树
        return buildTreeNodes(menuMap, parentId);
    }

    /**
     * 递归构建树节点
     *
     * @param menuMap 以父菜单ID为键，以子菜单列表为值的Map
     * @param parentId 父菜单ID
     * @return 当前层级的菜单列表，包含子菜单
     */
    private List<Menu> buildTreeNodes(Map<Long, List<Menu>> menuMap, long parentId) {
        // 获取当前层级的菜单列表
        List<Menu> menuTree = menuMap.get(parentId);
        if (menuTree != null) {
            // 遍历当前层级的菜单列表
            for (Menu menu : menuTree) {
                // 递归构建子菜单
                List<Menu> children = buildTreeNodes(menuMap, menu.getId());
                if (children != null) {
                    // 将子菜单设置为当前菜单的子节点
                    menu.setChildren(children);
                }
            }
        }
        // 返回当前层级的菜单列表，包含子菜单
        return menuTree;
    }



}
